"use strict";
/*
 * @Author: Fan Dong
 * @Date: 2021-06-24 14:14:22
 * @LastEditors: Fan Dong
 * @LastEditTime: 2021-06-24 14:57:14
 * @Description: 文件描述
 * @FilePath: \learn-typescript\ts\4.ts中的类.ts
 */
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
// 1、ts类的定义
/*
function Person(name){
  this.name = name;
  this.run = function(){
    console.log(this.name)
  }
}

let p = new Person('张三')
p.run();
*/
/*
ts中定义类
class Person {
  name: string; //属性 前面省略了 public关键词

  constructor(n: string){ // 构造函数  实例化的时候触发的方法
    this.name = n;
  }

  run():void{
    console.log(this.name)
  }
}

let p = new Person('张三')
p.run();

*/
// class Person {
//   name: string;
//   constructor(name: string) {
//     this.name = name;
//   }
//   getName(): string {
//     return this.name;
//   }
//   setName(name: string): void {
//     this.name = name;
//   }
// }
// let p = new Person("张三");
// console.log(p.getName());
// p.setName("李四");
// console.log(p.getName());
// 2、ts中实现继承 extends、super
// class Person {
//   name: string;
//   constructor(name: string) {
//     this.name = name;
//   }
//   run(): string {
//     return `${this.name}在运动`;
//   }
// }
// let p = new Person('王五')
// console.log(p.run())
// class Web extends Person {
//   constructor(name: string) {
//     super(name); // 初始化父类的构造函数
//   }
//   work(): void {
//     console.log(`${this.name}在工作`);
//   }
//   run(): string {
//     return `${this.name}在运动---子类`;
//   }
// }
// let w = new Web("李四");
// // 调用方法的时候先去子类里面找，如果子类没有再去父类找
// console.log(w.run());
// w.work();
// 3、类里面的修饰符 ts中里面定义属性的时候给我们定义了 三种修饰符
/*
  public: 公有的 在类里面、子类、类外面都可以访问
  protected： 保护类型 在类里面、子类里面可以访问、在类外部无法访问
  private： 私有  在类里面可以访问、子类、类外部都没法访问

  属性如果不加修饰符 默认就是公有的（public）
 */
/*
    public: 公有
    
  class Person {
    public name: string; //公有属性
    constructor(name: string) {
      this.name = name;
    }

    run(): string {
      return `${this.name}在运动`;
    }
  }

  class Web extends Person {
    constructor(name: string) {
      super(name); // 初始化父类的构造函数
    }
    work(): void {
      console.log(`${this.name}在工作`);
    }
    run(): string {
      return `${this.name}在运动---子类`;
    }
  }
  let w = new Web("李四");
  w.work();

  let p = new Person('哈哈哈')
  console.log(p.name)

  */
/*
  protected:保护类型 在类外部无法访问
  
class Person {
  protected name: string; //保护类型 在类外部无法访问
  constructor(name: string) {
    this.name = name;
  }

  run(): string {
    return `${this.name}在运动`;
  }
}

class Web extends Person {
  constructor(name: string) {
    super(name); // 初始化父类的构造函数
  }
  work(): void {
    console.log(`${this.name}在工作`);
  }
}
let w = new Web("李四");
w.work();
console.log(w.run());

let p = new Person("哈哈哈");
// console.log(p.name); //错误 protected外部无法访问

  */
var Person = /** @class */ (function () {
    function Person(name) {
        this.name = name;
    }
    Person.prototype.run = function () {
        return this.name + "\u5728\u8FD0\u52A8";
    };
    return Person;
}());
var Web = /** @class */ (function (_super) {
    __extends(Web, _super);
    function Web(name) {
        return _super.call(this, name) || this;
    }
    Web.prototype.work = function () {
        // console.log(`${this.name}在工作`); //错误
    };
    return Web;
}(Person));
var w = new Web("李四");
w.work();
console.log(w.run());
var p = new Person("哈哈哈");
console.log(p.run()); // 正确
// console.log(p.name); //错误
